home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 February / EnigmA AMIGA RUN 15 (1997)(G.R. Edizioni)(IT)[!][issue 1997-02][PLANET CD V].iso / progs / editor / frexxed / fpl / wordpro.fpl < prev    next >
Text File  |  1996-11-10  |  21KB  |  673 lines
  1. /*
  2.  * WHAT IS THIS?
  3.  *
  4.  * WordPro.FPL is perhaps the most advanced FPL program written for FrexxEd
  5.  * at this time. It brings interactive word-processor-style word wrap
  6.  * functionality to the editor.
  7.  *
  8.  * "word-processor-style" means that
  9.  * A. All word wrapping is "paragraph" oriented. All lines within the same
  10.  *    paragraph are separated with 'soft' newlines (that is a "\x01\n" in my
  11.  *    program!),
  12.  * B. If a line is longer than the right margin is set to, the words that are
  13.  *    "off the edge" are moved down to the line below and a 'soft' newline is
  14.  *    added to the end of the line. If the line below gets too long by the
  15.  *    operation, it performs the same with that line...
  16.  * C. If the first word of the line below would fit at the end of the current,
  17.  *    it is moved up. (And then the same check is done on the line below.)
  18.  */
  19.  
  20. /*
  21.  * Current restrictions:
  22.  *  o Pretty slow on large paragraphs, perhaps I'll make a limit in amount
  23.  *    of lines that can get 'fixed' on each invoke.
  24.  *  o If the first word of a line fits on the line above is only checked for
  25.  *    if the current line is out of right margin ( and '_fitprev' is on ).
  26.  *  o If the first word of the line below fits on the current line is only
  27.  *    checked for when deleting.
  28.  *  o There is no kind of left margin indentation support
  29.  */
  30.  
  31. /*
  32.  * WordProWrap()
  33.  *
  34.  * Checks the current line to see if it is longer than the margin allows.
  35.  * If it is, it performs actions to word wrap it properly
  36.  */
  37. export int WordProWrap(void)
  38. {
  39.   string word;
  40.   int sbyte = ReadInfo("byte_position");
  41.   int line = ReadInfo("line");
  42.   int sline=line;
  43.   int cursorline = line;
  44.   int jumpback;
  45.   int wrapped;
  46.   int len = ReadInfo("line_length");
  47.   int visible = Visible(0);
  48.   const int wall = ReadInfo("wall_right");
  49.   if(wall >= len)
  50.     return 1;
  51.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")+1);
  52.   do {
  53.     int steps;
  54.     int backsteps;
  55.     len = ReadInfo("line_length");
  56.     if(IsLineWordWrapped(line)) {
  57.       wrapped=1; /* it is wrapped! */
  58.       len--; /* don't count the cookie! */
  59.     }
  60.     else
  61.       wrapped=0;
  62.  
  63.     if(wall >= len)
  64.       break;
  65.  
  66. //    Request(sprintf("line %d is %d long wrapped %d", line, len, wrapped));
  67.     jumpback=1;
  68.     if(line == cursorline) {
  69.       /* the cursor-line */
  70.       if(ReadInfo("column") + (len-sbyte) >= wall) {
  71.         /* we reached the edge when appending text to the left side
  72.            of text that is about to get wrapped! */
  73.         backsteps= len-sbyte;  /* this number of steps from the current
  74.                         right edge */
  75.         jumpback=0;
  76.       }
  77.  
  78.       if(ReadInfo("WordPro_fitprev")) {
  79.         /*
  80.          * This checks if the first word on the line fits on the uppper line
  81.          */
  82.         while (IsLineWordWrapped(line-1)) {
  83.           int uplen;
  84.           GotoLine(line-1);
  85.           uplen = ReadInfo("line_length");
  86.           word = GetWord(line, 0);
  87.           if(sbyte > strlen(word) &&
  88.              uplen + strlen(word)+2 < wall) {
  89.             GotoLine(--line, len);
  90.             Backspace();
  91.             Delete();
  92.             Output(" ");
  93.             sbyte += uplen;
  94.             sline--;
  95.             //Request("We merged the line with the upper one!");
  96.           }
  97.           else {
  98.             GotoLine(line);
  99.             break;
  100.           }
  101.         }
  102.       }
  103.       /* ----- */
  104.       cursorline=-1; /* never ever do this again */
  105.       
  106.     }
  107.  
  108.     GotoLine(line, -1); /* jump to end of line! */
  109.     do {
  110.       steps+=CursorLeftWord();
  111.     } while (line==ReadInfo("line") &&
  112.              ReadInfo("column")>1 &&
  113.              wall<ReadInfo("column"));
  114.  
  115.     if(!jumpback && (steps < backsteps)) {
  116.       /* then this is a false backstepper! */
  117.       jumpback=1;
  118.     }
  119.     
  120. /*    Request(sprintf("line %d is %d long\nwrapped %d jumpback %d\nsline %d sbyte %d",
  121.                 line, len, wrapped, jumpback, sline, sbyte)); */
  122.  
  123.     if (line==ReadInfo("line") && ReadInfo("column")>1) {
  124.       int byte = ReadInfo("byte_position");
  125.       while(GetChar(--byte) != ' ') {
  126.          steps++;
  127.          CursorLeft();
  128.          if(!byte) {
  129.             GotoLine(line,wall);
  130.             Output("\x01\n");
  131.             break 2;
  132.          }
  133.       }
  134.       byte++;
  135.       while(GetChar(--byte) == ' ')
  136.         Backspace();
  137.       Output("\x01\n");
  138.     }
  139.     /*
  140.     if(wall <= ReadInfo("column")) {
  141.       Output("\x01\n");
  142.     }
  143.     */
  144.     line++; /* we've come down one line by now! */
  145.     if(!jumpback) {
  146.       jumpback=2;
  147.       sbyte = steps-backsteps;
  148.       sline = line;
  149.     }
  150.     if(wrapped) {
  151.       //Request("This is a wrapped line, check if next word fits here!");
  152.       len = ReadInfo("line_length");
  153.       word = GetWord(line+1, 0); /* get first word on next line */
  154.       if(strlen(word)+len < wall) {
  155.         /* we think next word is gonna fit on our line! */
  156.         GotoLine(line, len); /* jump to end of line! */
  157.         Backspace(); /* get rid of our 0x01 code! */
  158.         Delete(); /* Merge next line to our! */
  159.         if(GetChar()!=' ')
  160.           Output(" "); /* make us a space! */
  161.       }
  162.       else {
  163.         //Request("Nope! It doesn't...");
  164.         if(len < wall)
  165.           wrapped=0;
  166.       }
  167.     }
  168.     else if(1 != jumpback) {
  169.       /* If it *IS* a jumpback to the original position,
  170.          we wanna go back to the *SAME* position */
  171.       if(line < ReadInfo("lines") && !IsLineWordWrapped(line)) {
  172. //        Request(sprintf("boo %d", jumpback));
  173.         sbyte++;
  174.       }
  175.     }
  176.     /* Request(sprintf("line %d lines %d wrapped %d",
  177.                     line, ReadInfo("lines"), wrapped)); */
  178.   } while(wrapped); /* continue until done! */
  179.   if(jumpback) {
  180. //    Request(sprintf("sline %d sbyte %d", sline, sbyte));
  181.     GotoLine(sline, sbyte); /* jump to start-pos! */
  182.     // Request(sprintf("%d %d", sbyte, ReadInfo("line_length")));
  183.     if(IsLineWordWrapped(sline) &&
  184.        (sbyte>=ReadInfo("line_length")) ) {
  185.       GotoLine(sline, ReadInfo("line_length")-2);
  186.     }
  187.     if(GetCursor(sbyte, sline) < sbyte) {
  188.       GotoLine(sline+1);
  189.     }
  190.   }
  191.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")-1);
  192.   Visible(visible);
  193. }
  194.  
  195. /*
  196.  * WordProDelete0x01()
  197.  *
  198.  * Called before each invoke of Delete() to make a deletion of the 'soft'
  199.  * newline character (ASCII 0x01) make a deletion of the following
  200.  * newline too, and a decent word wrap if the line gets too long!
  201.  */
  202. int newlinedelete;
  203. export int WordProDelete0x01(int number)
  204. {
  205.   if(1 == GetChar()) { /* are we standing on a 0x01 character? */
  206.     int vis=Visible(0);
  207.     SetInfo(-1, "_wordpro", ReadInfo("_wordpro")+1);
  208.     if(number>1) /* specified number? */
  209.       number--;
  210.     Delete(number+2); /* delete the 0x01 and newline too then! */
  211.     WordProWrap(); /* wrap this long line! */
  212.     Visible(vis);
  213.     SetInfo(-1, "_wordpro", ReadInfo("_wordpro")-1);
  214.     return 1; /* quit the actual Delete() */
  215.   }
  216. }
  217.  
  218. /*
  219.  * WordProDelete()
  220.  *
  221.  * Called after each invoke of Delete() to make a decent word wrap if the
  222.  * line gets short enough to fit the first word on the line below!
  223.  */
  224. export int WordProDelete(void)
  225. {
  226.   int line=ReadInfo("line");
  227.   if(IsLineWordWrapped(line)) {
  228.     int len;
  229. /*    int sline=line; */
  230. /* old:    int sbyte=ReadInfo("byte_position"); */
  231.     int visible=Visible(0);
  232.     string word;
  233.     SetInfo(-1, "_wordpro", ReadInfo("_wordpro")+1);
  234.     CursorStack(-1); /* push current position */
  235.     while(line <= ReadInfo("lines")) {
  236.       if(!IsLineWordWrapped(line))
  237.         break;
  238.       word = GetWord(line+1, 0); /* get first word on next line */
  239.       if (!strlen(word))
  240.         /* no point if no string was there */
  241.         break;
  242.  
  243.       len = ReadInfo("line_length") + strlen(word)+1; /* a space too! */
  244.       if(ReadInfo("wall_right") > len) {
  245.         GotoLine(line++, -1); /* got to end of line */
  246.         Backspace(); /* remove magic cookie! */
  247.         Delete(); /* remove newline */
  248.         Output(" ");
  249.         WordProWrap(); /* do the dance! */
  250.       }
  251.       else
  252.         break;
  253.     }
  254.     CursorStack(1); /* pull previous cursor position */
  255. /* old:   GotoLine(sline, sbyte); jump to start-pos! */      
  256.     SetInfo(-1, "_wordpro", ReadInfo("_wordpro")-1);
  257.     Visible(visible);
  258.   }  
  259. }
  260.  
  261. /*
  262.  * This function is called _before_ a backspace, and the ...Past is called
  263.  * _after_ it. Compare the line numbers and if there is a change, scan
  264.  * the line you ended up on for 0x01 chars and replace them with ' '.
  265.  */
  266.  
  267. int backspaceline;
  268. int backspacevis;
  269.  
  270. export int WordProBackspace(void)
  271. {
  272.   backspaceline = ReadInfo("line");
  273.   Visible(0);
  274. }
  275.  
  276. export int WordProBackspacePast(void)
  277. {
  278.   int line = ReadInfo("line");
  279.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")+1); /* no recursion */
  280.   if( backspaceline != line) {
  281.     /* scan for and replace 0x01 with spaces */
  282.     int visible=Visible(0);
  283.     CursorStack(-1); /* push current position */
  284.     do {
  285.       CursorLeft();
  286. //      Request(sprintf("char %c", GetChar()));
  287.       if(1 == GetChar()) {
  288.         Delete();
  289.         Output(" ");
  290.         break; /* only replace one, we don't count on more than one */
  291.       }
  292.     } while( line == ReadInfo("line"));
  293.     CursorStack(1);  /* pull cursor position */
  294.     WordProWrap(); /* do the secret wrap trick! */
  295.     Visible(visible);
  296.     backspaceline = line;
  297.   }
  298.   else {
  299.     WordProDelete();
  300.   }
  301.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")-1); /* back */
  302.   Visible(1);
  303. }
  304.  
  305. /*
  306.  * WordProSave()
  307.  *
  308.  * Called before the actual save is done. If the user confirms the question,
  309.  * it replaces all soft newlines to spaces and then saves it like that.
  310.  */
  311. int oursavehook;
  312. export int WordProSave(string file, string pack)
  313. {
  314.   int new;
  315.   int savemode = ReadInfo("wordpro_save");
  316.   if(3 == savemode) {
  317.     savemode = Request("How do you want it saved?", "Save option",
  318.                        "Raw|Softs too|Only hards|Cancel");
  319.     if(!savemode--) {
  320.       return 1;
  321.     }
  322.   }
  323.   if(!oursavehook && savemode) {
  324.     int us = GetEntryID();
  325.     new = New();
  326.     oursavehook=1; /* prevent us from getting recursive! */
  327.     if(new) {
  328.       string filename;
  329.       string replacedsoft;
  330.       CurrentBuffer(new); /* jump to the new one */
  331.       BlockPaste(us); /* paste the original buffer in the new */
  332.       GotoLine(1); /* go to the top! */
  333.  
  334.       if(savemode==2) {
  335.         /* this is "only hard" newlines should be left, replace all softies
  336.            with a single space! */
  337.         replacedsoft = " ";
  338.       }
  339.       else {
  340.         /* Keep the soft newlines as newlines in the output! */
  341.         replacedsoft = "\n";
  342.       }
  343.       Replace(1, "\x01\n", replacedsoft, "f+"); /* replace all soft newlines */
  344.       
  345.       filename = ReadInfo("full_file_name", us); /* get file name */
  346.       if(strlen(file))
  347.         /* done like this to still support Save() with a given name */
  348.         filename=file;
  349.       Save(filename, pack); /* save the new buffer to the original file */
  350.       CurrentBuffer(us); /* jump back to the orignal buffer */
  351.  
  352.       /*
  353.        * Now, write the date and time of our "faked" save into the
  354.        * info variable for our good old buffer to maintain the proper
  355.        * data! (and most of all, to avoid that nasty 'FileChanged'
  356.        * exception when trying to save a file that is older than the file
  357.        * actually is on disk!)
  358.        */
  359.       SetInfo(us, "ds_Days", ReadInfo("ds_Days", new));
  360.       SetInfo(us, "ds_Minute", ReadInfo("ds_Minute", new));
  361.       SetInfo(us, "ds_Tick", ReadInfo("ds_Tick", new));
  362.  
  363.       SetInfo(us, "changes", 0); /* clear the changes flag! */
  364.       Kill(new); /* kill our temporary buffer */
  365.     }
  366.     oursavehook=0; /* allow us to get started once again! */
  367.   }
  368.   return new; /* if non-zero, the "real" save is stopped */
  369. }
  370.  
  371. /*
  372.  * WordProOpenAndWrap()
  373.  *
  374.  * This function takes the specified file, or if none is specified, prompts
  375.  * for one, loads it into a new buffer and word wraps it according to
  376.  * its knowledge.
  377.  */
  378. int export WordProOpenAndWrap(string file)
  379. {
  380.   int new;
  381.   if(!strlen(file)) {
  382.     file=PromptFile();
  383.     if(!strlen(file))
  384.       /* cancel or error occured! */
  385.       return 1;
  386.   }
  387.   new = New();
  388.   if(new) {
  389.     SetInfo(-1, "_wordpro", ReadInfo("_wordpro")+1); /* prevent recurse */
  390.     CurrentBuffer(new); /* jump to new buffer */
  391.     Load(file); /* load the specified file */
  392.     WordProWrapLines(1, ReadInfo("lines")); /* do the entire buffer! */
  393.     SetInfo(-1, "_wordpro", ReadInfo("_wordpro")-1); /* allow recurse */
  394.     SetInfo(-1, "wordpro", 1); /* 'wordpro' is enabled for this buffer! */
  395.   }
  396.   else
  397.     return 1;
  398. }
  399.  
  400. int export WordProWrapBuffer()
  401. {
  402.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")+1); /* prevent recurse */
  403.   WordProWrapLines(1, ReadInfo("lines")); /* do the entire buffer! */
  404.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")-1); /* allow recurse */
  405. }
  406.  
  407. int export WordProWrapBlock()
  408. {
  409.   if(ReadInfo("block_exist")) {
  410.     BlockMark(0);
  411.     WordProWrapLines(ReadInfo("block_begin_y"), ReadInfo("block_end_y"));
  412.   }
  413.   else
  414.     ReturnStatus("No block marked!");
  415. }
  416.  
  417. int export WordProWrapLines(int firstline, int lastline)
  418. {
  419.   int line;
  420.   int numlines;
  421.   int len;
  422.   int count;
  423.   int vis = Visible(0);
  424.  
  425.   SetInfo(-1, "wordpro", 1); /* we wanna run wordpro dammit! ;) */
  426.  
  427.   /* Do the tango!
  428.    *
  429.    * Combine all 'paragraphs' with soft newlines!
  430.    */
  431.   numlines = ReadInfo("lines"); /* read number of lines */
  432.   for(line= firstline; line < lastline; line++) { /* the last line can't be soft! */
  433.     len = GetByte(999999, line); /* get byte position */
  434.     if(len > ReadInfo("wall_right")/2 &&
  435.        !IsLineWordWrapped(line)) {
  436.       /* the text of this line reaches longer than half the width */
  437.       /* and it isn't previously wrapped (like if the file was saved 'raw'
  438.          in a previous WordPro editing session)! */
  439.       GotoLine(line, len); /* goto end of line */
  440.  
  441.       /* The expression just above does not fully function in FrexxEd 1.7
  442.          and earlier if the length of the line is longer than the width
  443.          of the screen/window... */
  444.       
  445.       if((GetByte(999999, line+1)>1) && !Isspace(GetChar(0, line+1))) {
  446.         /* The paragraph seems to continue on the following line,
  447.            since the first column of that line isn't white space! */
  448.         Output("\x01");
  449.       }
  450.     }
  451.     /* next one please! */
  452.   }
  453.   /*
  454.    * Now, let's scan all lines and wrap them to a decent level!
  455.    */
  456.   for(line= firstline; line <= lastline;) {
  457.     GotoLine(line); /* jump to the line in question! */
  458.     WordProWrap(); /* do the secret wrap trick! */
  459.     count = ReadInfo("lines")-numlines; /* this amount of new lines! */
  460.     numlines += count; /* we're at this amount now! */
  461.     lastline += count; /* add to this one too! */
  462.     if(count)
  463.       line += count; /* skip those new ones since they're already wrapped! */
  464.     else
  465.       line++;
  466.   }
  467.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")-1); /* allow yet again! */
  468.   Visible(vis);
  469. }
  470.  
  471. export void WordProPrefs()
  472. {
  473.   PromptInfo(-1, "WordPro Preferences", -1, -1,
  474.              "wordpro", "wall_right", "wordpro_save", "wordpro_fitprev",
  475.              "wordpro_open", "fill_text_US");
  476. }
  477.  
  478. int IsLineWordWrapped(int line)
  479. {
  480.   if(line>0) {
  481.     int len= GetByte(999999, line);
  482.     if(len>1 && (1 == GetChar(len-1, line))) {
  483.       return 1;
  484.     }
  485.   }
  486.   return 0;
  487. }
  488.  
  489. /*
  490.  * This function is built upon the basis written by Jesper Skov in his
  491.  * FillText.FPL 1.3. Only small modifications to fit WordPro standards
  492.  * added by me.
  493.  */
  494.  
  495. export string ft_indention="";
  496.  
  497. //»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»» fillText() ««
  498. export void WordProReWrapParagraph()
  499. {
  500.   int i=0;
  501.   int line;
  502.   int oldvis;
  503.  
  504.   if (ReadInfo("line_length")==1){
  505.     ReturnStatus("Place cursor in a paragraph!");
  506.     return;
  507.   }
  508.  
  509.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")+1); /* prevent recurse */
  510.  
  511.   oldvis = Visible(0);
  512.  
  513.   // Find topmost line
  514.   line = ReadInfo("line");
  515.   while(line>1 && IsLineWordWrapped(line-1)) {
  516.     Home();
  517.     Backspace(2); /* remove the special newline character on the line
  518.                      above too */
  519.     Output(" ");
  520.     line--;
  521.   }
  522.   Home();
  523.   while(IsLineWordWrapped(line)) {
  524.     CursorDown();
  525.     Home();
  526.     Backspace(2); /* remove the special newline character on the line
  527.                      above too */
  528.     Output(" ");
  529.   }
  530.   Home();
  531.  
  532.   // Copy&delete leading spaces
  533.   while(Isspace(GetChar(i)))
  534.     i++;
  535.   ft_indention = substr(GetLine(),0,i);
  536.   Delete(i);
  537.  
  538.   BlockMark(0);
  539.   BlockMark(2,0,ReadInfo("line"),GetCursor(ReadInfo("line_length")),ReadInfo("line"));
  540.  
  541.   Home();
  542.   Replace(1,"\t"," ","=bf+",ReadInfo("line_length")); // replace tabs with space
  543.   Home();
  544.   Replace(1,"  +"," ","=bfw+",ReadInfo("line_length")); // replace multiple spaces with space
  545.   Home();
  546.   if(ReadInfo("fill_text_US")){                // if wanted, set US double space
  547.     Replace(1,". ",".  ","=bf+");
  548.     Home();
  549.   }
  550.  
  551.   BlockMark(0);
  552.  
  553.   Clean("Output(ft_indention);");
  554.  
  555.   // Now split line up in valid sized single lines
  556.   while(GetCursor(ReadInfo("line_length"))>ReadInfo("wall_right")){
  557.     // If a word is crossing the wall_right, go left of it.
  558.     GotoLine(ReadInfo("line"),GetByte(ReadInfo("wall_right")));
  559.       while(!Isspace(GetChar(ReadInfo("byte_position")-1))){
  560.       CursorLeftWord();
  561.       if (ReadInfo("column")==1){            // very long word!
  562.         CursorRightWord();                // simply go back!
  563.         break;
  564.       }
  565.     }
  566.     Backspace();
  567.     if (Isspace(GetChar(ReadInfo("byte_position")-1)))
  568.       Backspace();                    // clear extra for US .
  569.     Output("\x01\n"+ft_indention);
  570.   }     
  571.  
  572.   // Delete last space there may be after a .
  573.   GotoLine(ReadInfo("line"),-1);
  574.   if(Isspace(GetChar(ReadInfo("byte_position")-1)))
  575.     Backspace();
  576.   if (Isspace(GetChar(ReadInfo("byte_position"))))
  577.     Delete();                    // clear extra for US .
  578.  
  579.   Visible(oldvis);
  580.   SetInfo(-1, "_wordpro", ReadInfo("_wordpro")-1); /* allow recurse */
  581. }
  582.  
  583. export void WordProReWrapBuffer()
  584. {
  585.   int vis = Visible(0);
  586.   GotoLine(1);
  587.   while(ReadInfo("line") < ReadInfo("lines")) {
  588.      WordProReWrapParagraph();
  589.      CursorDown();
  590.   }
  591.   WordProReWrapParagraph(); /* do the last line once too B) */
  592.   Visible(vis);
  593. }
  594.  
  595. ReadInfo("_wordpro");
  596. if(GetErrNo()) { /* just a way to make the menu only once, even if this file
  597.                     is executed repeatedly! */
  598.   /*
  599.    * Create our menu setup:
  600.    */
  601.   MenuAdd("t", "WordPro");
  602.     MenuAdd("i", "Open...", "WordProOpenAndWrap(\"\");", "control w o");
  603.     MenuAdd("i", "Save...", "Save();", "control w s");
  604.     MenuAdd("i", "Prefs...", "WordProPrefs();");
  605.     MenuAdd("i", "---");
  606.     
  607.      /* these items below calls the function ripped from FillText.FPL that
  608.         Jesper Skov nicely has contributed with */
  609.     MenuAdd("i", "Reformat");
  610.       MenuAdd("s", "Paragraph", "WordProReWrapParagraph();", "control w p");
  611.       MenuAdd("s", "Buffer", "WordProReWrapBuffer();");
  612.       
  613.     MenuAdd("i", "WordProify");
  614.       MenuAdd("s", "Block", "WordProWrapBlock();", "control w b");
  615.       MenuAdd("s", "Buffer", "WordProWrapBuffer();", "control w u");
  616.   MenuBuild();
  617. }
  618.  
  619. /*
  620.  * This little beast is here only to prevent recursion where we don't want
  621.  * it...
  622.  */
  623. ConstructInfo("_wordpro", "", "", "ILH", "", 0, 999, 0);
  624.  
  625. /*
  626.  * This is the general right-edge setting.
  627.  */
  628. ConstructInfo("wall_right", "", "", "WIL(display)", "", 0, 999, 79);
  629.  
  630. /*
  631.  * Toggle this mode on/off with this!
  632.  */
  633. ConstructInfo("wordpro", "", "", "WBL(system)", "", 0, 0);
  634.  
  635. /*
  636.  * Control how the saving is performed with this.
  637.  */
  638. ConstructInfo("wordpro_save", "", "", "WCG(system)", "Raw|Softs too|Only Hards|Query", 0, 0, 2);
  639.  
  640. /*
  641.  * Make all the regular loads word wrap the file!
  642.  */
  643. ConstructInfo("wordpro_open", "", "", "WBG(system)", "", 0, 0, 0);
  644.  
  645. /*
  646.  * This variable enables the wordpro script to check if the first word of
  647.  * the line fits on the line above.
  648.  */
  649. ConstructInfo("wordpro_fitprev", "", "", "WBG(system)", "", 0, 0, 1);
  650.  
  651. //»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»» Info vars ««
  652. ConstructInfo("fill_text_US","","","WBG(display)","",0,1,0);
  653.  
  654. FACT(0x01, 'S', "^", ' '); /* non-visible character! */
  655.  
  656. AddMode(0,"wordpro", "","");                // Add as minor mode!
  657.  
  658. /*
  659.  * All this can only be accomplished by some pretty extensive hooking...
  660.  */
  661.  
  662. HookPast("Output", "WordProWrap();", "wordpro&!_wordpro");
  663. HookPast("BlockPaste", "WordProWrap();", "wordpro&!_wordpro");
  664. HookPast("Delete", "WordProDelete();", "wordpro&!_wordpro");
  665. HookPast("Backspace", "WordProBackspacePast();", "wordpro&!_wordpro");
  666. HookPast("DeleteWord", "WordProDelete();", "wordpro&!_wordpro");
  667. HookPast("BackspaceWord", "WordProBackspacePast();", "wordpro&!_wordpro");
  668. Hook("Save", "WordProSave", "wordpro");
  669. Hook("Delete", "WordProDelete0x01", "wordpro&!_wordpro");
  670. Hook("GotFile", "WordProWrapBuffer();", "wordpro_open&!_wordpro");
  671. Hook("Backspace", "WordProBackspace();", "wordpro&!_wordpro");
  672. Hook("BackspaceWord", "WordProBackspace();", "wordpro&!_wordpro");
  673.